/*
 * MenuConnexion.java
 * Construction du menu de connexion
 *
 */

package Risk.IHM;

import java.awt.BorderLayout;
import java.awt.Desktop;
import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import java.io.File;
import java.io.IOException;

import java.util.StringTokenizer;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.swing.BorderFactory;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JSplitPane;
import javax.swing.SwingConstants;
import javax.swing.filechooser.FileNameExtensionFilter;

/**
 * @author Nicoleta Sergi
 * Construit la fenetre du menu principal
 */
public class MenuConnexion extends JFrame implements ActionListener {
    // variables statiques
    private static final long	serialVersionUID = 1L;
    // ici on a que des imageicon, on utilisera donc que le repertoire Icons
    public static final String	cheminImg = "Images/Icons/";
    // nom des images pour pouvoir les modifier si besoin
    public static final String[]	nomImages = {
	"jeu.png", "retour.png", "charger.png", "sauver.png", "help.png", "quitter.png"
    };
    //etape du jeu
    public static EtapeJeu	etape            = EtapeJeu.DEBUT;
    // acces au menu depuis d'autres classes
    public static MenuConnexion	menuConnect;
    // booleens pour savoir quels boutons ont ete cliques
    public static boolean	nouvPartie, jeuComm, sauvegarde, charger, startServer;
    
    //acces au plateau de la partie , utilise pour le retour a une partie en cours
    private PlateauIhm		dernierPlateau;

    // fenetre de connexion au serveur - > Sebastien
    private ConnexionServeurIHM	fenetreConnexionServeur;

    // boutons de la fenetre
    private JButton	jbNouvPartie, jbRetourPartie, jbCharger, jbSauver, jbAide, jbQuitter, jbStartServ;

    // mon tableau qui regroupe les boutons, utilise pour l'amelioration du code
    private JButton[]	mes_boutons;

    // pour la gestion des boutons
    public static enum EtapeJeu {
	DEBUT, NOUV_PARTIE, PARTIE_COMMENCEE, SAUVEGARDE, START_SERV
    };
    
    /**
     * Constructeur sans parametre
     */
    public MenuConnexion() {
	super("Interface Risk");
	MenuConnexion.menuConnect = this;
	fenetreConnexionServeur   = new ConnexionServeurIHM();
	mes_boutons               = new JButton[ 6 ];
	initComponents(this);
	updateCommandButtons(etape);
	this.setLocation(50, 50);
	this.addWindowListener(new WindowAdapter() {
	    @Override
	    public void windowClosing(WindowEvent e) {
		int	reponse = JOptionPane.showConfirmDialog(menuConnect, " Vous-etes sur de vouloir quitter ? ",
				      " Fermeture connexion ", JOptionPane.YES_NO_OPTION);

		if (reponse == JOptionPane.YES_OPTION) {
		    System.exit(0);
		}

		// dans tous les autres cas
		menuConnect.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
	    }
	});
	this.pack();
        
        // position de la fenetre
	Dimension	ecran = Toolkit.getDefaultToolkit().getScreenSize();       
        Dimension frameSize = this.getSize();
        this.setLocation((ecran.width - frameSize.width)/2,(ecran.height - frameSize.height)/2);
        
	this.setVisible(true);
    }

    /**
     * evenements sur le boutons
     * @param e - l'evenement declencheur
     */
    public void actionPerformed(ActionEvent e) {
	String	cheminFich;
	String	radicalFich;
	String	nomFich;
	JButton	jb = (JButton) e.getSource();

	if (jb.equals(jbQuitter)) {

	    // teste si l'utilisateur a deja sauvegarde sa partie
	    int	reponse = JOptionPane.showConfirmDialog(this, " Vous-etes sur de vouloir quitter ? ",
			      " Fermeture connexion ", JOptionPane.YES_NO_OPTION);

	    if (reponse == JOptionPane.YES_OPTION) {
		System.exit(0);
	    }
	}

	if (jb.equals(jbRetourPartie)) {
	    this.setVisible(false);
	    dernierPlateau.setVisible(true);
	    dernierPlateau.setEnabled(true);
            if (ConnexionServeurIHM.CONNECTE) {
		dernierPlateau.getRisk().setTc(MenuConnexion.menuConnect.getFenetreConnexionServeur().getTc());
	    }
	}

	if (jb.equals(jbCharger)) {
	    JFileChooser		jfc    = new JFileChooser("./Sauvegardes");
	    FileNameExtensionFilter	filter = new FileNameExtensionFilter("Fichiers de sauvegarde", "sav");

	    jfc.setFileFilter(filter);

	    int	returnVal = jfc.showOpenDialog(this);

	    if (returnVal == JFileChooser.APPROVE_OPTION) {
		File	fichier = jfc.getSelectedFile();

		nomFich = fichier.getName();

		StringTokenizer	st = new StringTokenizer(nomFich, ".");

		radicalFich = st.nextToken();
		cheminFich  = fichier.getParent();
		cheminFich  += File.separator;

		Chargement	c = new Chargement(cheminFich + nomFich);
	    }
	}

	/* Fait la sauvegarde de la partie */
	if (jb.equals(jbSauver)) {
	    updateCommandButtons(etape.SAUVEGARDE);

	    // Sebastien : TRAITEMENT -> Sauvegarde
	    Sauvegarde	s = new Sauvegarde(dernierPlateau.getRisk());
	}

	/* Lance la fenetre pour configurer une nouvelle partie */
	if (jb.equals(jbNouvPartie)) {
	    updateCommandButtons(etape.NOUV_PARTIE);

	    ConfigNouvellePartie	np = new ConfigNouvellePartie();

	    this.setVisible(false);
	}

	/* Lance la fenetre de connexion au serveur -> Sebastien */
	if (jb.equals(jbStartServ)) {
	    updateCommandButtons(etape.START_SERV);
	    fenetreConnexionServeur.setVisible(true);
	}

	if (jb.equals(jbAide)) {
	    try {
		Desktop.getDesktop().open(new File("Manuel_Utilisateur.pdf"));
	    } catch (IOException ex) {
		ex.printStackTrace();
	    }
	}
    }

    /**
     * methode qui active ou desactive tous les boutons
     * @param etat - le nouvel etat de tous les boutons
     */
    public void etatBoutons(boolean etat) {
	for (int i = 0; i < mes_boutons.length; i++) {
	    mes_boutons[ i ].setEnabled(etat);
	}
    }

    /**
     * initialisation des composantes graphques de la fenetre
     * @param frame - la fenetre parent
     */
    private void initComponents(JFrame frame) {

	/* panel qui contient les boutons principaux */
	JPanel	jpBoutons = new JPanel(new GridLayout(6, 1));
	JPanel	jpImage   = new JPanel(new BorderLayout());

	/* image de l'icone du jeu */
	ImageIcon	imgIc = new ImageIcon(cheminImg + "Jeu.jpg");

	imgIc.setImage(imgIc.getImage().getScaledInstance(imgIc.getIconWidth(), imgIc.getIconHeight(),
		Image.SCALE_DEFAULT));

	JLabel	jlImage = new JLabel(imgIc);

	jpImage.add(jlImage, BorderLayout.CENTER);

	// boutons
	// nouvelle partie
	jbNouvPartie = new JButton(" Nouveau jeu ");
	jbNouvPartie.setHorizontalAlignment(SwingConstants.LEFT);
	jbNouvPartie.setMnemonic(KeyEvent.VK_N);
	jbNouvPartie.setDisplayedMnemonicIndex(1);
	mes_boutons[ 0 ] = jbNouvPartie;

	// retour partie
	jbRetourPartie = new JButton(" Retour partie ");
	jbRetourPartie.setHorizontalAlignment(SwingConstants.LEFT);
	jbRetourPartie.setMnemonic(KeyEvent.VK_R);
	jbRetourPartie.setDisplayedMnemonicIndex(1);
	mes_boutons[ 1 ] = jbRetourPartie;

	// charger
	jbCharger = new JButton(" Charger... ");
	jbCharger.setHorizontalAlignment(SwingConstants.LEFT);
	jbCharger.setMnemonic(KeyEvent.VK_C);
	jbCharger.setDisplayedMnemonicIndex(1);
	mes_boutons[ 2 ] = jbCharger;

	// sauver
	jbSauver = new JButton(" Sauver ... ");
	jbSauver.setHorizontalAlignment(SwingConstants.LEFT);
	jbSauver.setMnemonic(KeyEvent.VK_S);
	jbSauver.setDisplayedMnemonicIndex(1);
	mes_boutons[ 3 ] = jbSauver;

	// aide
	jbAide = new JButton(" Aide ");
	jbAide.setHorizontalAlignment(SwingConstants.LEFT);
	jbAide.setMnemonic(KeyEvent.VK_A);
	jbAide.setDisplayedMnemonicIndex(1);
	mes_boutons[ 4 ] = jbAide;

	// quitter
	jbQuitter = new JButton(" Quitter ");
	jbQuitter.setHorizontalAlignment(SwingConstants.LEFT);
	jbQuitter.setMnemonic(KeyEvent.VK_Q);
	jbQuitter.setDisplayedMnemonicIndex(1);
	mes_boutons[ 5 ] = jbQuitter;

	// parcours du tableau pour ajouter les boutons au panel jpBoutons,
	// personnalisation des boutons avec bordure et icone
	// et ajout des actions listeners sur les boutons
	for (int i = 0; i < mes_boutons.length; i++) {
	    mes_boutons[ i ].addActionListener(this);
	    mes_boutons[ i ].setBorder(BorderFactory.createRaisedBevelBorder());
	    mes_boutons[ i ].setIcon(new ImageIcon(cheminImg + nomImages[ i ]));
	    jpBoutons.add(mes_boutons[ i ]);
	}

	// diviseur ecran
	JSplitPane	jsp = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, jpImage, jpBoutons);

	frame.add(jsp, BorderLayout.CENTER);

	/* bouton pour demarrer le serveur */
	jbStartServ = new JButton(" CONNEXION SERVEUR ");
	jbStartServ.setBorder(BorderFactory.createRaisedBevelBorder());
	jbStartServ.setIcon(new ImageIcon(cheminImg + "run.png"));
	jbStartServ.addActionListener(this);
	frame.add(jbStartServ, BorderLayout.SOUTH);
    }

    /**
     * methode de gestion des etats des boutons a l'aide d'une enumeration
     * @param status - l'etat du bouton
     */
    public void updateCommandButtons(EtapeJeu status) {

	// les deux derniers boutons : aide et quitter restent actives tout le tps
	switch (status) {
	case DEBUT :
	    etatBoutons(true);

	    // bouton retour desactive tant qu'une partie n'est pas lancee
	    mes_boutons[ 1 ].setEnabled(false);

	    // Sebastien : bouton sauvegarde desactive tant qu'une partie n'est pas lancee
	    mes_boutons[ 3 ].setEnabled(false);

	    // DEBUG
	    // System.out.println("debut de partie");
	    break;

	case NOUV_PARTIE :
	    nouvPartie = true;

	    // DEBUG
	    // System.out.println("bouton nouvelle partie");
	    break;

	case PARTIE_COMMENCEE :
	    jeuComm = true;

	    // bouton retour active
	    mes_boutons[ 1 ].setEnabled(true);

	    // Sebastien : bouton sauvegarde active
	    mes_boutons[ 3 ].setEnabled(true);

	    // DEBUG
	    // System.out.println("la partie est commencee");
	    break;

	case SAUVEGARDE :
	    sauvegarde = true;

	    // DEBUG
	    // System.out.println("bouton sauvegarde");
	    break;

	case START_SERV :

	    // DEBUG
	    // System.out.println(" Connexion au serveur ");
	    break;    // Sebastien: Ajout du break

	default :

	    // TRAITEMENT -> Nicoleta
	    // il faudrait tester si il n'y a pas deja un serveur qui tourne
	    jbStartServ.setEnabled(false);
	}
    }
    /**
     * getter pour recuperer la fenetre de connexion au serveur
     * @return - une instance de ConnexionServeurIHM
     */
    public ConnexionServeurIHM getFenetreConnexionServeur() {
	return fenetreConnexionServeur;
    }
    /**
     * setter sur le plateau du jeu
     * @param p - le nouvel plateau (utilise pour le retour a la partie)
     */
    public void setDernierPlateau(PlateauIhm p) {
	dernierPlateau = p;
    }
}
